// pages/user/mine/profile/index.js
const auth = require('../../../../utils/auth')
const userApi = require('../../../../api/user')

Page({
  data: {
    userInfo: {
      name: '',
      id: '',
      idCard: '',
      gender: '',
      birthDate: '',
      phone: '',
      province: '',
      city: '',
      county: '',
      village: '',
      address: '',
      postalCode: '',
      role: '',
      avatar: ''
    },
    // 全局加载状态
    globalLoading: false,
    globalLoadingText: '用户信息加载中...',
    originalUserInfo: {}, // 保存原始数据用于重置
    saving: false,
    maxDate: '', // 出生日期的最大日期（当前日期）
    // 地理信息数据
    regionValue: [], // region选择器的值数组 [省份, 城市, 区县]
    regionDisplayText: '', // 显示文本
    villages: [],
    villageIndex: 0,
    // 性别选项
    genders: [
      { name: '男', value: 'male' },
      { name: '女', value: 'female' }
    ],
    genderIndex: 0
  },

  // 显示全局加载
  showGlobalLoading(text = '用户信息加载中...') {
    const app = getApp()
    app.showGlobalLoading({
      loadingText: text
    })
  },

  // 隐藏全局加载
  hideGlobalLoading() {
    const app = getApp()
    app.hideGlobalLoading()
  },

  // 更新全局加载状态
  updateGlobalLoading(data) {
    this.setData({
      globalLoading: data.globalLoading,
      globalLoadingText: data.globalLoadingText || this.data.globalLoadingText
    })
  },

  onLoad(options) {
    // 显示页面加载效果
    this.showGlobalLoading('用户信息加载中...')
    // 设置出生日期的最大日期为当前日期
    const today = new Date()
    const maxDate = today.getFullYear() + '-' + 
                   String(today.getMonth() + 1).padStart(2, '0') + '-' + 
                   String(today.getDate()).padStart(2, '0')
    
    this.setData({ maxDate })
    
    this.loadUserInfo()
    
    // 延迟检查数据加载状态
    setTimeout(() => {
      this.checkDataStatus()
    }, 100)
  },

  // 检查数据加载状态
  checkDataStatus() {
    console.log('数据加载状态检查:', {
      regionValue: this.data.regionValue,
      regionDisplayText: this.data.regionDisplayText,
      villages: this.data.villages?.length || 0
    })
  },



  onShow() {
    // 每次显示时刷新用户信息
    this.loadUserInfo()
    
    // 延迟设置索引，确保数据完全加载
    setTimeout(() => {
      this.setRegionValue()
      this.setGenderIndex()
    }, 200)
  },

  // 加载用户信息
  loadUserInfo() {
    const role = auth.getCurrentRole()
    if (role) {
      const userInfo = wx.getStorageSync('USER_INFO') || {}
      console.log('从本地存储加载的用户信息:', userInfo)
      
      const userData = {
        name: userInfo.name || '',
        id: userInfo.accountNumber || '', // 使用 accountNumber 作为用户ID显示
        idCard: userInfo.idCard || '',
        gender: userInfo.gender || '',
        birthDate: this.formatBirthDate(userInfo.birthDate), // 格式化出生日期
        phone: userInfo.phone || '',
        province: userInfo.province || '',
        city: userInfo.city || '',
        county: userInfo.county || '',
        village: userInfo.village || '',
        address: userInfo.address || '',
        postalCode: userInfo.postalCode || '',
        role: role,
        avatar: userInfo.avatar || ''
      }
      
      console.log('设置到页面的用户数据:', userData)
      
      this.setData({
        userInfo: userData,
        originalUserInfo: JSON.parse(JSON.stringify(userData))
      })
      
      // 设置地理信息索引
      this.setRegionValue()
      
      // 设置性别索引
      this.setGenderIndex()
      
      // 调试：显示所有用户信息字段
      console.log('用户信息字段检查:', {
        name: userData.name,
        birthDate: userData.birthDate,
        birthDateFormatted: this.formatBirthDate(userData.birthDate),
        province: userData.province,
        city: userData.city,
        county: userData.county,
        village: userData.village,
        address: userData.address,
        postalCode: userData.postalCode
      })
      
      // 延迟执行数据回显
      setTimeout(() => {
        this.testDataDisplay()
        // 隐藏全局加载状态
        this.hideGlobalLoading()
      }, 500)
    } else {
      // 隐藏全局加载状态
      this.hideGlobalLoading()
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      })
      setTimeout(() => {
        wx.navigateBack()
      }, 1500)
    }
  },


  // 设置region选择器的值
  setRegionValue() {
    const { userInfo } = this.data
    
    console.log('设置region选择器值，用户信息:', {
      province: userInfo.province,
      city: userInfo.city,
      county: userInfo.county
    })
    
    // 构建region选择器的值数组
    const regionValue = []
    if (userInfo.province) regionValue.push(userInfo.province)
    if (userInfo.city) regionValue.push(userInfo.city)
    if (userInfo.county) regionValue.push(userInfo.county)
    
    // 构建显示文本
    const regionDisplayText = regionValue.length > 0 ? regionValue.join(' ') : ''
    
    this.setData({
      regionValue,
      regionDisplayText
    })
    
    // 如果有县区信息，加载村庄数据
    if (userInfo.county) {
      this.loadVillages(userInfo.county)
    }
  },


  // 加载村庄数据
  loadVillages(countyName) {
    // 这里可以保留原有的村庄数据加载逻辑
    // 或者根据实际需求调整
    console.log('加载村庄数据:', countyName)
    
    // 模拟村庄数据，实际项目中应该从服务器获取
    const mockVillages = [
      { name: '村一', value: 'village1' },
      { name: '村二', value: 'village2' },
      { name: '村三', value: 'village3' }
    ]
    
    this.setData({ villages: mockVillages })
    
    // 设置村庄索引
    const villageIndex = mockVillages.findIndex(v => v.name === this.data.userInfo.village)
    if (villageIndex >= 0) {
      this.setData({ villageIndex })
    }
  },

  // 输入事件处理
  onNameInput(e) {
    this.setData({
      'userInfo.name': e.detail.value
    })
  },

  onIdCardInput(e) {
    this.setData({
      'userInfo.idCard': e.detail.value
    })
  },

  onPostalCodeInput(e) {
    this.setData({
      'userInfo.postalCode': e.detail.value
    })
  },

  onPhoneInput(e) {
    this.setData({
      'userInfo.phone': e.detail.value
    })
  },

  onAddressInput(e) {
    this.setData({
      'userInfo.address': e.detail.value
    })
  },

  // 省市区选择
  onRegionChange(e) {
    const regionValue = e.detail.value
    console.log('选择的省市区:', regionValue)
    
    // 更新用户信息
    this.setData({
      regionValue,
      'userInfo.province': regionValue[0] || '',
      'userInfo.city': regionValue[1] || '',
      'userInfo.county': regionValue[2] || '',
      regionDisplayText: regionValue.join(' '),
      // 重置村庄相关数据
      villageIndex: 0,
      'userInfo.village': '',
      villages: []
    })
    
    // 如果有县区信息，加载村庄数据
    if (regionValue[2]) {
      this.loadVillages(regionValue[2])
    }
  },

  onVillageChange(e) {
    const index = e.detail.value
    const village = this.data.villages[index]
    
    this.setData({
      villageIndex: index,
      'userInfo.village': village.name
    })
  },

  // 性别选择
  onGenderChange(e) {
    const index = e.detail.value
    const gender = this.data.genders[index]
    
    this.setData({
      genderIndex: index,
      'userInfo.gender': gender.value  // 使用value而不是name
    })
  },

  // 出生日期选择
  onBirthDateChange(e) {
    const selectedDate = e.detail.value
    console.log('用户选择的出生日期:', selectedDate)
    console.log('格式化后的日期:', this.formatBirthDate(selectedDate))
    
    this.setData({
      'userInfo.birthDate': selectedDate
    })
    
    // 验证选择的日期
    if (!this.isValidBirthDate(selectedDate)) {
      console.warn('选择的出生日期格式无效:', selectedDate)
    }
  },

  // 设置性别索引
  setGenderIndex() {
    const { userInfo, genders } = this.data
    const genderIndex = genders.findIndex(g => g.value === userInfo.gender)
    this.setData({ 
      genderIndex: genderIndex >= 0 ? genderIndex : 0 
    })
  },

  // 选择头像
  onChooseAvatar() {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album', 'camera'],
      sizeType: ['compressed'], // 使用压缩图片
      success: (res) => {
        const tempFile = res.tempFiles[0]
        const tempFilePath = tempFile.tempFilePath
        
        // 在控制台显示文件信息
        console.log('选择的头像文件信息:', {
          tempFilePath: tempFilePath,
          size: tempFile.size,
          duration: tempFile.duration,
          width: tempFile.width,
          height: tempFile.height,
          fileType: tempFile.fileType
        })
        
        // 上传头像到服务器
        this.uploadAvatarToServer(tempFilePath)
      },
      fail: (err) => {
        console.error('选择头像失败:', err)
        this.showAvatarError('选择头像失败，请重试')
      }
    })
  },

  // 上传头像到服务器
  async uploadAvatarToServer(filePath) {
    try {
      // 显示上传进度
      console.log('开始上传头像到服务器:', filePath)
      
      // 调用上传API
      const result = await userApi.uploadAvatar(filePath)
      
      if (result.success) {
        const avatarUrl = result.data.url
        console.log('头像上传成功，服务器URL:', avatarUrl)
        
        // 更新页面数据和本地存储
        this.saveAvatarLocally(avatarUrl)
        
        // 显示成功提示
        this.showAvatarSuccess('头像上传成功')
      } else {
        throw new Error(result.message || '上传失败')
      }
      
    } catch (error) {
      console.error('上传头像失败:', error)
      this.showAvatarError('头像上传失败: ' + error.message)
    } finally {
            this.hideGlobalLoading();
      }
  },

  // 保存头像到本地存储和页面数据
  saveAvatarLocally(avatarUrl) {
    try {
      // 格式化头像URL
      const formattedAvatarUrl = this.formatAvatarUrl(avatarUrl)
      
      // 更新页面数据中的用户信息
      this.setData({
        'userInfo.avatar': formattedAvatarUrl
      })
      
      // 更新本地存储
      const currentUserInfo = wx.getStorageSync('USER_INFO') || {}
      currentUserInfo.avatar = formattedAvatarUrl
      wx.setStorageSync('USER_INFO', currentUserInfo)
      
      console.log('头像已保存到用户信息:', {
        userInfo: this.data.userInfo,
        localStorage: currentUserInfo,
        avatarUrl: formattedAvatarUrl
      })
    } catch (error) {
      console.error('保存头像失败:', error)
      this.showAvatarError('头像保存失败，请重试')
    }
  },

  // 格式化头像URL
  formatAvatarUrl(avatarUrl) {
    if (!avatarUrl) return '';
    
    // 如果已经是完整的URL，直接返回
    if (avatarUrl.startsWith('http://') || avatarUrl.startsWith('https://')) {
      return avatarUrl;
    }
    
    // 如果是相对路径，添加服务器地址
    if (avatarUrl.startsWith('/uploads/')) {
      const app = getApp();
      const baseUrl = app.globalData.baseUrl || 'http://localhost:3000';
      return `${baseUrl}${avatarUrl}`;
    }
    
    // 其他情况直接返回
    return avatarUrl;
  },

  // 显示头像上传成功提示
  showAvatarSuccess(message) {
    wx.showModal({
      title: '操作成功',
      content: message,
      showCancel: false,
      confirmText: '确定',
      success: () => {
        // 可以在这里添加其他成功后的操作
      }
    })
  },

  // 显示头像操作失败提示
  showAvatarError(message) {
    wx.showModal({
      title: '操作失败',
      content: message,
      showCancel: false,
      confirmText: '确定'
    })
  },

  // 数据回显
  testDataDisplay() {
    console.log('=== 数据回显 ===')
    console.log('当前页面数据:', this.data.userInfo)
    console.log('本地存储数据:', wx.getStorageSync('USER_INFO'))
    console.log('出生日期调试:', {
      pageBirthDate: this.data.userInfo.birthDate,
      formattedBirthDate: this.formatBirthDate(this.data.userInfo.birthDate),
      isValidBirthDate: this.isValidBirthDate(this.data.userInfo.birthDate)
    })
    console.log('地理信息:', {
      regionValue: this.data.regionValue,
      regionDisplayText: this.data.regionDisplayText,
      villageIndex: this.data.villageIndex
    })
    console.log('性别索引:', this.data.genderIndex)
  },

  // 保存用户信息
  async onSave() {
    const { userInfo } = this.data
    
    // 验证必填字段
    if (!userInfo.name.trim()) {
      wx.showToast({
        title: '请输入姓名',
        icon: 'none'
      })
      return
    }

    // 验证身份证号码
    if (userInfo.idCard && !this.isValidIdCard(userInfo.idCard)) {
      wx.showToast({
        title: '身份证号码格式不正确',
        icon: 'none'
      })
      return
    }

    // 验证手机号格式
    if (userInfo.phone && !this.isValidPhone(userInfo.phone)) {
      wx.showToast({
        title: '手机号格式不正确',
        icon: 'none'
      })
      return
    }

    // 验证出生日期格式
    if (userInfo.birthDate && !this.isValidBirthDate(userInfo.birthDate)) {
      wx.showToast({
        title: '出生日期格式不正确',
        icon: 'none'
      })
      return
    }

    this.setData({ saving: true })

    try {
      // 获取当前用户信息用于身份验证
      const currentUser = auth.getCurrentUser()
      
      if (!currentUser) {
        wx.showToast({
          title: '用户信息异常，请重新登录',
          icon: 'none'
        })
        return
      }

      // 检查用户信息是否完整
      if (!currentUser.accountNumber) {
        wx.showModal({
          title: '用户信息不完整',
          content: '当前用户信息不完整，请重新登录后再试',
          showCancel: false,
          confirmText: '重新登录',
          success: () => {
            // 清除本地用户信息
            auth.clearCurrentUser()
            // 跳转到登录页面
            wx.navigateTo({
              url: '/pages/auth/login/index'
            })
          }
        })
        return
      }

      // 准备提交的数据 - 优先使用 accountNumber
      const loginIdentifier = currentUser.accountNumber || currentUser.username || currentUser.phone
      
      // 处理头像URL - 如果是本地路径，需要先上传到服务器
      let avatarUrl = userInfo.avatar
      if (avatarUrl && avatarUrl.startsWith('wxfile://')) {
        try {
          console.log('检测到本地头像，需要上传到服务器:', avatarUrl)
          const uploadResult = await userApi.uploadAvatar(avatarUrl)
          if (uploadResult.success) {
            avatarUrl = uploadResult.data.url
            console.log('头像上传成功，服务器URL:', avatarUrl)
          } else {
            console.warn('头像上传失败，使用原路径:', avatarUrl)
          }
        } catch (error) {
          console.error('头像上传失败:', error)
          // 如果上传失败，继续使用原路径
        }
      }
      
      const updateData = {
        loginIdentifier: loginIdentifier,
        name: userInfo.name,
        idCard: userInfo.idCard,
        gender: userInfo.gender,
        birthDate: this.formatBirthDate(userInfo.birthDate), // 确保日期格式正确
        phone: userInfo.phone,
        province: userInfo.province,
        city: userInfo.city,
        county: userInfo.county,
        village: userInfo.village,
        address: userInfo.address,
        postalCode: userInfo.postalCode,
        avatar: avatarUrl
      }
      
      console.log('保存个人信息时的头像数据:', userInfo.avatar)
      console.log('处理后的头像URL:', avatarUrl)
      console.log('提交给后端的数据:', updateData)
      console.log('村庄数据检查:', {
        village: userInfo.village,
        villageIndex: this.data.villageIndex,
        villages: this.data.villages
      })

      // 调用后端接口保存个人信息
      const result = await userApi.updateProfile(updateData)
      
      if (result.success) {
        console.log('后端返回的数据:', result.data)
        
        // 处理 null 值，将 null 转换为空字符串，并格式化日期
        const processedData = {}
        Object.keys(result.data).forEach(key => {
          let value = result.data[key] === null ? '' : result.data[key]
          // 特殊处理出生日期字段
          if (key === 'birthDate' && value) {
            value = this.formatBirthDate(value)
          }
          processedData[key] = value
        })
        
        console.log('处理后的数据:', processedData)
        
        // 更新本地存储
        const updatedUserInfo = {
          ...currentUser,
          ...processedData
        }
        auth.setCurrentUser(updatedUserInfo)
        
        // 更新页面数据
        const updatedUserData = {
          ...userInfo,
          ...processedData
        }
        
        this.setData({
          userInfo: updatedUserData,
          originalUserInfo: JSON.parse(JSON.stringify(updatedUserData))
        })
        
        // 重新设置地理信息索引和性别索引
        setTimeout(() => {
          console.log('保存成功后重新设置索引，当前用户数据:', updatedUserData)
          this.setRegionValue()
          this.setGenderIndex()
        }, 100)
        
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        })

        // 通知其他页面数据已更新
        wx.setStorageSync('USER_INFO_UPDATED', Date.now())
        
        // 延迟返回上一页
        setTimeout(() => {
          wx.navigateBack()
        }, 1500)
        
      } else {
        wx.showToast({
          title: result.message || '保存失败',
          icon: 'none'
        })
      }
      
    } catch (error) {
      console.error('保存个人信息失败:', error)
      
      // 检查是否是服务器返回的业务错误
      if (error && error.message) {
        wx.showToast({
          title: error.message,
          icon: 'none'
        })
      } else {
        wx.showToast({
          title: '网络错误，保存失败',
          icon: 'none'
        })
      }
    } finally {
      this.setData({ saving: false })
    }
  },

  // 重置表单
  onReset() {
    wx.showModal({
      title: '确认重置',
      content: '确定要重置所有修改吗？',
      success: (res) => {
        if (res.confirm) {
          this.setData({
            userInfo: JSON.parse(JSON.stringify(this.data.originalUserInfo))
          })
          this.setRegionValue()
          this.setGenderIndex()
          
          wx.showToast({
            title: '已重置',
            icon: 'success'
          })
        }
      }
    })
  },

  // 验证身份证号码格式
  isValidIdCard(idCard) {
    const idCardRegex = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/
    return idCardRegex.test(idCard)
  },

  // 验证手机号格式
  isValidPhone(phone) {
    const phoneRegex = /^1[3-9]\d{9}$/
    return phoneRegex.test(phone)
  },

  // 格式化出生日期
  formatBirthDate(birthDate) {
    if (!birthDate) return ''
    
    // 如果已经是 YYYY-MM-DD 格式，直接返回
    if (typeof birthDate === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(birthDate)) {
      return birthDate
    }
    
    // 如果是 Date 对象，转换为 YYYY-MM-DD 格式
    if (birthDate instanceof Date) {
      const year = birthDate.getFullYear()
      const month = String(birthDate.getMonth() + 1).padStart(2, '0')
      const day = String(birthDate.getDate()).padStart(2, '0')
      return `${year}-${month}-${day}`
    }
    
    // 如果是其他格式的字符串，尝试解析
    if (typeof birthDate === 'string') {
      try {
        const date = new Date(birthDate)
        if (!isNaN(date.getTime())) {
          const year = date.getFullYear()
          const month = String(date.getMonth() + 1).padStart(2, '0')
          const day = String(date.getDate()).padStart(2, '0')
          return `${year}-${month}-${day}`
        }
      } catch (error) {
        console.error('日期解析失败:', error)
      }
    }
    
    return ''
  },

  // 验证出生日期格式
  isValidBirthDate(birthDate) {
    if (!birthDate) return true // 允许空值
    
    // 检查格式是否为 YYYY-MM-DD
    const dateRegex = /^\d{4}-\d{2}-\d{2}$/
    if (!dateRegex.test(birthDate)) {
      return false
    }
    
    // 检查日期是否有效
    const date = new Date(birthDate)
    const year = date.getFullYear()
    const month = date.getMonth() + 1
    const day = date.getDate()
    
    // 检查日期是否在合理范围内
    const currentYear = new Date().getFullYear()
    if (year < 1900 || year > currentYear) {
      return false
    }
    
    // 检查月份和日期是否有效
    if (month < 1 || month > 12 || day < 1 || day > 31) {
      return false
    }
    
    return true
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.loadUserInfo()
    
    setTimeout(() => {
      wx.stopPullDownRefresh()
    }, 1000)
  }
})